Reader Testimonials

English Edition

       "Arguably the quickest and easiest way to get up to speed on 
       the most important parts of the C++ standard library. Recommended 
       for any modern C++ programmer."

German Edition

       "Das Buch beinhaltet, wie der Name schon sagt, eine recht 
       ausführliche Beschreibung der STL. Dabei merkt Mann deutlich dass 
       der Autor auch selber auf hohem Niveau programmiert. Es gibt oft 
       den ein oder andere Tipp oder Wink in die richtige Richtung die 
       bei Bücher von Berufsautoren oft fehlen. Z.B. die Aussage dass 
       std::vector für 95% aller Fälle die beste Wahl ist oder dass 
       std::async meistens die erste Wahl sein sollte lenkt der Leser 
       geschickt in die richtige Richtung.
       
       Auch die Auswahl an Komponente aus der STL ist sehr gut getroffen 
       (keiner kann in ein kürzen Buch die ganze STL beschreiben). Oft 
       sehe ich, vor allem in Deutschsprachige Literatur, dass die Auswahl 
       eher auf Komponente trifft die leicht zu beschreiben sind und nicht 
       auf die Nützlichen. Eine gute und dennoch kürze Beschreibung vom 
       std::regex z.B. ist weiß Gott nicht einfach aber in diesem Fall ist 
       es der Autor sehr gelungen."

       "Die 215 Seiten plus Index des 'C++ kurz & gut' vom Autor Rainer Grimm 
       stellen ein gelungene Destillat viel umfangreicherer Texte zum Thema 
       da. So nimmt das Kapitel über die klassischen Algorithmen der 
       Standardbibliothek ganze 131 Seiten ein. Selbst kurze Beispiele für die 
       Anwendung der wichtigsten Bestandteile der Standardbibliothek passen 
       eng gedruckt in das schmale Büchlein. Auch wenn heute Tools wie Dash 
       oder entsprechend ausgestattete IDEs, mehr und mehr den Platz derartiger
       Desktop-Referenzen einnehmen, ist das 'kurz & gut' zu C++ 
       Standardbibliothek ein leichter und mobiler Begleiter für jeden C++ 
       Entwickler. Und als Kindle Version um so bequemer mitzunehmen."

Introduction

About Me

I work as a software architect, team lead, and instructor since 1999. In 2002, I created a further education round at my company. I give seminars since 2002. My first seminars were about proprietary management software, but seminars for Python and C++ followed immediately. In my spare time, I like to write articles about C++, Python, and Haskell. I also like to speak at conferences. I publish weekly on my English Modernes Cpp and the German blog, hosted by Heise Developer.

Since 2016, I am an independent instructor giving seminars about modern C++ and Python. I published several books in various languages about modern C++ and concurrency, in particular. Due to my profession, I always search for the best way to teach modern C++.

Purpose of this Book

The C++ Standard Library is a quick reference to the standard library of the current C++ standard C++20 ISO/IEC 14882:2020. C++20 has more than 1800 pages and is the next big C++ standard after C++17. C++17 is neither a big nor a small C++ standard. C++14 is a small addition to C++11. C++11 had more than 1,300 pages and was published 2011. That was 13 years after the first and only C++ standard C++98. Of course, there is also C++03, published in 2003. But C++03 is considered a bug fix release.

The goal of this quick reference is to provide a concise reference to the C++ standard library. This book assumes that you are familiar with C++. If so you will get the most benefit out of this book. If C++ is new to you, you should start with a textbook about core C++. Once you have mastered a textbook about the core language, you can make your next big step by reading this book. To make your job easier, I have provided a lot of short code snippets to connect theory and practice.

Index

The book should be a reference for C++, and should, therefore, have an index. Leanpub does not support the creation of an index. So I’ve made it based on regular expressions, naming conventions, a lot of python magic - don’t blame me - and a long, long table which I had to split for each page. Here is the problem. The index is only fully available in the pdf format of the book.

Conventions

I promise only a few conventions.

Special Fonts

Italic

I use Italic if something is essential.

Monospace

I use Monospace for code, instructions, keywords and names of types, variables, functions, and classes.

Special Boxes

I use boxes for unique information, tips, and warning.

Source Examples

I dislike using directives and declarations because they hide the namespace of the library functions, but because of the limited length of a page, I have to use them from time to time. I use them in such a way that the origin can always be deduced from the using directive (using namespace std;) or the using declaration (using std::cout;).

Only header files of the featured functionality are shown in the code snippets. True or false is displayed in the output code snippets for boolean values; and

std::boolalpha is not used.

Source Code

To be concise, I only present short code snippets in this book. The name of the entire program is in the first line of the code snippet.

Value versus Object

I call instances of fundamental data types values, which C++ inherited from C. Instances of more advanced types which often consist of fundamental types, are called objects. Objects are typically instances of user-defined types or containers.

Acknowledgements

At first Alexandra Follenius, who was the lector at O’Reilly for the German book C++ Standardbibliothek. You may have guessed that the German book is the ancestor of this book. For my book C++ Standardbibliothek Karsten Ahnert, Guntram Berti, Dmitry Ganyushin, Sven Johannsen, Torsten Robitzki, Bart Vandewoestyne, and Felix Winter were very valuable proofreaders. A lot of thanks to all of them.

For translating this book to English, I started a request in my English blog: www.ModernesCpp.com. I received a much higher response than I expected. Special thanks to all of you, including my son Marius, who was the first proofreader.

Here are the names in alphabetic order: Mahesh Attarde, Rick Audet, Pete Barrow, Michael Ben-David, Dave Burns, Alvaro Fernandez, Juliette Grimm, George Haake, Clare Macrae, Arne Mertz, Ian Reeve, Jason Turner, Bart Vandewoestyne, Ivan Vergiliev, and Andrzej Warzynski.

Further Information

The idea of the book is quite easy to paraphrase: “What every professional C++ programmer should know about the C++ standard library.” Because of this intention, I left a lot of answers unanswered; therefore, I provide you with the links to the details at the very beginning of each new topic. The link will be referring to the excellent online resource www.cppreference.com.

C++ versus C++11

Who can characterise C++11 better than Bjarne Stroustrup, creator of C++:

Surprisingly, C++11 feels like a new language: The pieces just fit together better than they used to and I find a higher-level style of programming more natural than before and as efficient as ever. (Bjarne Stroustrup, http://www.stroustrup.com/C++11FAQ.html)

Bjarne Stroustrup is right. C++11 feels like a new language because it has a lot to offer in addition to classic C++. This is true for the core language and is even more true for the improved and extended standard library. The regular expression library for the manipulation of text, the type-traits library to get, compare or manipulate types, the new random numbers library or the chrono library are all new with C++11. But that’s not all. There are the smart pointers for automatic memory management and the new containers std::array and std::tuple, which are further improved in C++14. C++11 is for the first time aware of multiple threads and offers a multithreading library.

1. The Standard Library

The C++ standard library consists of many components. This chapter serves two purposes. It should give you a quick overview of the components and a first idea how to use them.

The History

C++ and therefore the standard library have a long history. C++ started in the 1980s of the last millennium and ended now in 2020. Anyone who knows about software development knows how fast our domain evolves. So 30 years is a very long period. You may not be so astonished that the first components of C++, like I/O streams, were designed with a different mindset than the modern Standard Template Library (STL). This evolution in the area of software development in the last 30 years, which you can observe in the C++ standard library, is also an evolution in the way software problems are solved. C++ started as an object-oriented language, then incorporated generic programming with the STL and now has adopted a lot of functional programming ideas.

The first C++ standard library from 1998 had three components. Those were the previously mentioned I/O streams, mainly for file handling, the string library and the Standard Template Library. The Standard Template Library facilitates the transparent application of algorithms on containers.

The history continues in the year 2005 with Technical Report 1 (TR1). The extension to the C++ library ISO/IEC TR 19768 was not an official standard, but almost all of the components became part of C++11. These were, for example, the libraries for regular expressions, smart pointers, hash tables, random numbers and time, based on the boost libraries (http://www.boost.org/).

In addition to the standardisation of TR1, C++11 got one new component: the multithreading library.

C++14 was only a small update to the C++11 standard. Therefore only a few improvements to the already existing libraries for smart pointers, tuples, type traits and multithreading were added.

C++17 includes libraries for the file system and the two new data types std::any and std::optional.

C++20 has four outstanding features: concepts, ranges, coroutines, modules

Overview

As C++11 has a lot of libraries, it is often not so easy to find the convenient one for each use case.

Utilities

Utilities are libraries which have a general focus and therefore can be applied in many contexts.

Examples of utilities are functions to calculate the minimum or maximum of values or functions, the midpoint of two values, or to swap or move values.

Thanks to save comparison of integers, integral promotion does not kick in.

Other utilities are std::function, std::bind, or std:bind_front With std::bind or std::bind_front you can easily create new functions from existing ones. To bind them to a variable and invoke them later, you have std::function.

With std::pair and it’s generalisation std::tuple you can create heterogeneous pairs and tuples of arbitrary length.

The reference wrappers std::ref and std::cref are pretty handy. One can use them to create a reference wrapper for a variable, which for std::cref is const.

Of course, the highlights of the utilities are the smart pointers. They allow explicit automatic memory management in C++. You can model the concept of explicit ownership with std::unique_ptr and model shared ownership with std::shared_ptr. std::shared_ptr uses reference counting for taking care of its resource. The third one, std::weak_ptr, helps to break the cyclic dependencies among std::shared_ptrs, the classic problem of reference counting.

The type traits library is used to check, compare and manipulate type information at compile time.

The time library is an import addition of the new multithreading capabilities of C++. But it is also quite handy to make performance measurements and includes support for calender and time zone.

With std::any, std::optional, and std::variant, we get with C++17 three special datatypes that can have any, an optional value, or a variant of values.

The Standard Template Library

The Standard Template Library (STL) consists of three components from a bird’s-eye view. Those are containers, algorithms that run on the containers, and iterators that connect both of them. This abstraction of generic programming enables you to combine algorithms and containers in a unique way. The containers have only minimal requirements for their elements.

The C++ Standard Library has a rich collection of containers. From a bird’s eye we have sequence and associative containers. Associative containers can be classified as ordered or unordered associative containers.

Each of the sequence containers has a unique domain, but in 95 % of the use cases std::vector is the right choice. std::vector can dynamically adjust its size, automatically manages its memory and provides you with outstanding performance. In contrast, std::array is the only sequence container that cannot adjust its size at runtime. It is optimised for minimal memory and performance overhead. While std::vector is good at putting new elements at its end, you should use std::deque to put an element also at the beginning. With std::list being a doubly-linked list and std::forward_list as a singly linked list, we have two additional containers that are optimised for operations at arbitrary positions in the container, with high performance.

Associative containers are containers of key-value pairs. They provide their values by their respective key. A typical use case for an associative container is a phone book, where you use the key family name to retrieve the value phone number. C++ has eight different associative containers. On one side there are the associative containers with ordered keys: std::set, std::map, std::multiset and std::multimap. On the other side there are the unordered associative containers: std::unordered_set, std::unordered_map, std::unordered_multiset and std::unordered_multimap.

Let’s look first at the ordered associative containers. The difference between std::set and std::map is that the former has no associated value. The difference between std::map and std::multimap is, that the latter can have more than one identical key. This naming conventions also holds for the unordered associative containers, which have a lot in common with the ordered ones. The key difference is the performance. While the ordered associative containers have an access time depending logarithmically on the number of elements, the unordered associative containers allow constant access time. Therefore the access time of the unordered associative containers is independent of their size. The same rule holds true for std::map as it does for std::vector. In 95 % of all use cases std::map should be your first choice for an associative container because the keys are sorted.

Container adapters provide a simplified interface to the sequence containers. C++ has std::stack, std::queue and std::priority_queue.

std::span is a view on a contiguous sequence of elements. C-array, std::array, std::vector, or std::string support views. A view is never an owner.

Iterators are the glue between the containers and the algorithms. The container creates them. As generalised pointers, you can use them to iterate forward and backwards or to an arbitrary position in the container. The type of iterator you get depends on the container. If you use an iterator adapter, you can directly access a stream.

The STL gives you more than 100 algorithms. By specifying the execution policy, you can run most of the algorithms sequential, parallel, or parallel and vectorised. Algorithms operate on elements or a range of elements. Two iterators define a range. The first one defines the beginning, the second one, called end iterator, defines the end of the range. It’s important to know that the end iterator points to one element past the end of the range.

The algorithms can be used in a wide range of applications. You can find elements or count them, find ranges, compare or transform them. There are algorithms to generate, replace or remove elements from a container. Of course, you can sort, permute or partition a container or determine the minimum or maximum element of it. A lot of algorithms can be further customised by callables like functions, function objects or lambda-functions. The callables provide special criteria for search or elements transformation. They highly increase the power of the algorithm.

The algorithms of the ranges library are lazy, can work directly on the container and can easily be composed. They extend C++ with functional ideas.

Numeric

There are two libraries for numerics in C++: the random numbers library and the mathematical functions, which C++ inherited from C.

The random numbers library consists of two parts. On one side there is the random number generator, on the other side, the distribution of the generated random numbers. The random number generator generates a stream of numbers between a minimum and a maximum value, which the random number distribution maps onto the concrete distribution.

Because of C, C++ has a lot of mathematical standard functions. For example there are logarithmic, exponential and trigonometric functions.

C++ supports basic and advanced mathematical constants such as , , or .

Text Processing

With strings and regular expressions, C++ has two powerful libraries to process text.

std::string possesses a rich collection of methods to analyze and modify its text. Because it has a lot in common with a std::vector of characters, the algorithms of the STL can be used for std::string. std::string is the successor of the C string but a lot easier and safer to use. C++ strings manage their own memory.

In contrast to a std::string a std::string_view is quite cheap to copy. A std::string_view is a non-owning reference to a std::string.

Regular expression is a language for describing text patterns. You can use regular expressions to determine whether a text pattern is present once or more times in a text. But that’s not all. Regular expressions can be used to replace the content of the matched patterns with a text.

Input and Output

I/O streams library is a library, present from the start of C++, that allows communication with the outside world.

Communication means in this concrete case that the extraction operator (>>) enables it to read formatted or unformatted data from the input stream, and the insertion operator (<<) enables it to write the data on the output stream. Data can be formatted using manipulators.

The stream classes have an elaborate class hierarchy. Two stream classes are significant: First, string streams allow you to interact with strings and streams. Second, file streams allow you to read and write files easily. The state of streams is kept in flags, which you can read and manipulate.

By overloading the input operator and output operator, your class can interact with the outside world like a fundamental data type.

The formatting library provides a safe and extensible alternative to the printf family and extends the I/O streams library.

In contrast to the I/O streams library, filesystem library was added to the C++-Standard with C++17. The library is based on the three concepts file, file name and path. Files can be directories, hard links, symbolic links or regular files. Paths can be absolute or relative.

The filesystem library supports a powerful interface for reading and manipulating the filesystem.

Multithreading

C++ gets with the 2011 published C++ standard a multithreading library. This library has basic building blocks like atomic variables, threads, locks and condition variables. That’s the base on which future C++ standards can build higher abstractions. But C++11 already knows tasks, which provide a higher abstraction than the cited basic building blocks.

At a low level, C++11 provides for the first time a memory model and atomic variables. Both components are the foundation for well-defined behaviour in multithreading programming.

A new thread in C++ will immediately start its work. It can run in the foreground or background and gets its data by copy or reference. Thanks to the stop token, you can interrupt the improved thread std::jthread.

The access of shared variables between threads has to be coordinated. This coordination can be done in different ways with mutexes or locks. But often it’s sufficient to protect the initialisation of the data as it will be immutable during its lifetime.

Declaring a variable as thread-local ensures that a thread get its own copy, so there is no conflict.

Condition variables are a classic solution to implement sender-receiver workflows. The key idea is that the sender notifies the receiver when it’s done with its work, so the receiver can start.

Semaphores are a synchronisation mechanism used to control concurrent access to a shared resource. A semaphore has a counter that is bigger than zero. Acquiring the semaphore decreases the counter and releasing the semaphore increases the counter. A thread can only acquire the ressource when the counter is greater then zero.

Similar to semaphores, std::latch and std::barrier are coordination types which enable some threads to block until a counter becomes zero. In constrast to a std::barrier, you can resue a std::latch for a new iteration and adjust its counter for this new iteration.

Tasks have a lot in common with threads. But while a programmer explicitly creates a thread, a task will be implicitly created by the C++ runtime. Tasks are like data channels. The promise puts data into the data channel, the future picks the value up. The data can be a value, an exception or simply a notification.

Coroutines are functions that can suspend and resume their execution while keeping their state. Coroutines are the usual way to write event-driven applications. The event-driven application can be simulations, games, servers, user interfaces, or even algorithms. Coroutines are typically used for cooperative multitasking. The key to cooperative multitasking is that each task takes as much time as it needs.

Application of Libraries

To use a library in a file you have to perform three steps. At first, you have to include the header files with the #include statement, so the compiler knows the names of the library. Because the names of the C++ standard library are in the namespace std, you can use them in the second step fully qualified or you have to import them in the global namespace. The third and final step is to specify the libraries for the linker to get an executable. This third step is often not necessary. The three steps are explained below.

Include Header Files

The preprocessor includes the file, following the #include statement. That is most of the time a header file. The header files will be enclosed in angle brackets:

#include <iostream>
#include <vector>

Usage of Namespaces

If you use qualified names, you have to use them exactly as defined. For each namespace you must put the scope resolution operator ::. More libraries of the C++ standard library use nested namespaces.

#include <iostream>
#include <chrono>
...
std::cout << "Hello world:" << std::endl;
auto timeNow= std::chrono::system_clock::now();

Unqualified Use of Names

You can use names in C++ with the using declaration and the using directive.

Using Declaration

A using declaration adds a name to the visibility scope, in which you applied the using declaration:

#include <iostream>
#include <chrono>
...
using std::cout;
using std::endl;
using std::chrono::system_clock;
...
cout << "Hello world:" << endl; // unqualified name
auto timeNow= now();            // unqualified name

The application of a using declaration has the following consequences:

• An ambiguous lookup and therefore a compiler error occur, if the same name was declared in the same visibility scope.
• If the same name was declared in a surrounding visibility scope, it will be hidden by the using declaration.

Using Directive

The using directive permits it to use all names of a namespace without qualification.

#include <iostream>
#include <chrono>
...
using namespace std;
...
cout << "Hello world:" << endl;            // unqualified name
auto timeNow= chrono::system_clock::now(); // partially qualified name

A using directive adds no name to the current visibility scope, it only makes the name accessible. That implies:

• An ambiguous lookup and therefore a compiler error occur, if the same name was declared in the same visibility scope.
• A name in the local namespace hides a name declared in a surrounding namespace.
• An ambiguous lookup and therefore a compiler error occurs if the same name get visible from different namespaces or if a name in the namespace hides a name in the global scope.

Namespace Alias

A namespace alias defines a synonym for a namespace. It’s often convenient to use an alias for a long namespace or nested namespaces:

#include <chrono>
...
namespace sysClock= std::chrono::system_clock;
auto nowFirst= sysClock::now();
auto nowSecond= std::chrono::system_clock::now();

Because of the namespace alias, you can address the now function qualified and with the alias. A namespace alias must not hide a name.

Build an Executable

It is only seldom necessary to link explicitly against a library. That sentence is platform dependent. For example, with the current g++ or clang++ compiler, you have to link against the pthread library to get the multithreading functionality.

g++ -std=c++14 thread.cpp -o thread -pthread

2. Utilities

Utilities are useful tools which can be used in many different contexts. They are not bound to a typical domain. That sentence holds for the functions and libraries of this chapter. I explain to you functions which you can apply on arbitrary values or functions which you can use to create new functions and binds them to variables. You can store arbitrary values of arbitrary types in pairs and tuples, or you can build references to arbitrary values. Smart pointers are your tool to implement automatic memory management in C++. To get information about your types, use the type-traits library.

Useful Functions

The many variations of the min, max and minmax functions are applicable on values and initialiser lists. These functions need the header <algorithm>. Nearly the same holds for the functions std::move, std::forward and std::swap. You can apply them to arbitrary values. These three functions are defined in the header <utility>.

std::min, std::max and std::minmax

The functions std::min, std::max and std::minmax, defined in the header <algorithm>, act on values and initialiser lists and give you the requested value back as result. In the case of std::minmax, you get a std::pair. The first element of the pair is the minimum, the second the maximum of the values. By default, the less operator (<) is used, but you can specify your comparison operator. This function needs two arguments and returns a boolean. Functions either return true or false are called predicates.

// minMax.cpp
...
#include <algorithm>
...
using std::cout;
...
cout << std::min(2011, 2014);                           // 2011
cout << std::min({3, 1, 2011, 2014, -5});               // -5
cout << std::min(-10, -5, [](int a, int b)
                { return std::abs(a) < std::abs(b); }); // -5

auto pairInt= std::minmax(2011, 2014);
auto pairSeq= std::minmax({3, 1, 2011, 2014, -5});
auto pairAbs= std::minmax({3, 1, 2011, 2014, -5}, [](int a, int b)
                      { return std::abs(a) < std::abs(b); });

cout << pairInt.first << "," << pairInt.second;  // 2011,2014
cout << pairSeq.first << "," << pairSeq.second;  // -5,2014
cout << pairAbs.first << "," << pairAbs.second;  // 1,2014

The table provides an overview of the functions std::min, std::max and std::minmax

std::midpoint and std::lerp

The function std::midpoint(a, b) calculates the midpoint between a and b. a and b can be integers, floating-point numbers, or pointers. If a and b are pointers, they have to point to the same array object. The function std::midpoint requires the header <numeric>.

The function std::lerp(a, b, t) calculates the linear arithmetic of two numbers. It requires the header <cmath>. The return value is a + t(b - a).

// midpointLerp.cpp

#include <cmath>
#include <numeric>

...

std::cout << "std::midpoint(10, 20): " << std::midpoint(10, 20) << std::endl;
    
for (auto v: {0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0}) {
    std::cout << "std::lerp(10, 20, " << v << "): " << std::lerp(10, 20, v) << "\n";
}

std::move

The function std::move, defined in the header <utility>, empowers the compiler to move it’s resource. In the so-called move semantic, the values from the source object are moved to the new object. Afterwards the source is in a well-defined but not specified state. Most of the times that is the default state of the source. By using std::move, the compiler converts the source arg to a rvalue reference: static_cast<std::remove_reference<decltype(arg)>::type&&> (arg). If the compiler can not apply the move semantic, it falls back to the copy semantic:

#include <utility>
...
std::vector<int> myBigVec(10000000, 2011);
std::vector<int> myVec;

myVec = myBigVec;             // copy semantic
myVec = std::move(myBigVec);  // move semantic

std::forward

The function std::forward, defined in the header <utility>, empower you to write function templates, which can identically forward their arguments. Typical use cases for std::forward are factory functions or constructors. Factory functions are functions which create an object and must therefore identically pass the arguments. Constructors often use their arguments to initialise their base class with identical arguments. So std::forward is the perfect tool for authors of generic libraries:

// forward.cpp
...
#include <utility>
...
using std::initialiser_list;

struct MyData{
  MyData(int, double, char){};
};

template <typename T, typename...  Args>
  T createT(Args&&... args){
  return T(std::forward<Args>(args)... );
}

...

int a= createT<int>();
int b= createT<int>(1);

std::string s= createT<std::string>("Only for testing.");
MyData myData2= createT<MyData>(1, 3.19, 'a');

typedef std::vector<int> IntVec;
IntVec intVec= createT<IntVec>(initialiser_list<int>({1, 2, 3}));

The function template createT has to take their arguments as a universal reference: Args&&… args`. A universal reference or also called forwarding reference is a rvalue reference in a type deduction context.

std::swap

With the function std::swap defined in the header <utility>, you can easily swap two objects. The generic implementation in the C++ standard library internally uses the function std::move.

// swap.cpp
...
#include <utility>
...
template <typename T>
inline void swap(T& a, T& b) noexcept {
    T tmp(std::move(a));
    a = std::move(b);
    b = std::move(tmp);
}

Save Comparison of Integers

The functions of the <utility> header std::cmp_equal, std::cmp_not_equal, std::cmp_less, std::cmp_greater, std::cmp_less_equal, and std::cmp_greater_equal provide safe comparison of integers. Safe comparison means, that the comparison of a negative signed integer always compares less than an unsigned integer, and that the comparison of values other than a signed or unsigned integer gives a compile time error.

Adaptors for Functions

The two functions std::bind, std::bind_front and std::functions fit very well together. While std::bind or std::bind_front enables you to create new function objects on the fly, std::function takes these temporary function objects and binds them to a variable. The function std::bind is more powerful than std::bind_front because std::bind allows it to bind the arguments to an arbitrary position. These functions are powerful tools from functional programming and require the header <functional>.

// bindAndFunction.cpp 
...
#include <functional>
...
// for placehoder _1 and _2
using namespace std::placeholders; 

using std::bind;
using std::bind_front;
using std::function
...
double divMe(double a, double b){ return a/b; };
function<double(double, double)> myDiv1 = bind(divMe, _1, _2);
function<double(double)> myDiv2 = bind(divMe, 2000, _1);
function<double(double>> myDiv3 = bind_front(divMe, 2000);

divMe(2000, 10) == myDiv1(2000, 10) == myDiv2(10) == myDiv3(10);

std::bind

Because of std::bind, you can create function objects in a variety of ways:

• bind the arguments to an arbitrary position,
• change the order of the arguments,
• introduce placeholders for arguments,
• partially evaluate functions,
• invoke the newly created function objects, use them in the algorithm of the STL or store them in std::function.

std::bind_front

std::bind_front creates an callable wrapper from a callable. A call std::bind_front(func, arg ...) binds all arguments arg to the front of func and returns a callable wrapper.

std::function

std::function can store arbitrary callables in variables. It’s a kind of polymorphic function wrapper. A callable may be a lambda function, a function object or a function. std::function is always necessary and can’t be replaced by auto, if you have to specify the type of the callable explicitly.

// dispatchTable.cpp 
...
#include <functional>
...
using std::make_pair;
using std::map;

map<const char, std::function<double(double, double)>> tab;
tab.insert(make_pair('+', [](double a, double b){ return a + b; }));
tab.insert(make_pair('-', [](double a, double b){ return a - b; }));
tab.insert(make_pair('*', [](double a, double b){ return a * b; }));
tab.insert(make_pair('/', [](double a, double b){ return a / b; }));

std::cout << tab['+'](3.5, 4.5);  // 8
std::cout << tab['-'](3.5, 4.5);  // -1
std::cout << tab['*'](3.5, 4.5);  // 15.75
std::cout << tab['/'](3.5, 4.5);  // 0.777778

The type parameter of std::function defines the type of callables std::function will accept.

Pairs

With std::pair, you can build pairs of arbitrary types. The class template std::pair needs the header <utility>. std::pair has a default, copy and move constructor. Pair objects can be swapped: std::swap(pair1, pair2).

Pairs will often be used in the C++ library. For example, the function std::minmax returns its result as a pair, the associative container std::map, std::unordered_map, std::multimap and std::unordered_multimap manage their key/value association in pairs.

To get the elements of a pair p, you can either access it directly or via an index. So, with p.first or std::get<0>(p) you get the first, with p.second or std::get<1>(p) you get the second element of the pair.

Pairs support the comparison operators ==, !=, <, >, <= and >=. If you compare two pairs for identity, at first the members pair1.first and pair2.first will be compared and then pair1.second and pair2.second. The same strategy holds for the other comparison operators.

std::make_pair

C++ has the practical help function std::make_pair to generate pairs, without specifying their types. std::make_pair automatically deduces their types.

// pair.cpp
...
#include <utility>
...
using namespace std;
...
pair<const char*, double> charDoub("str", 3.14);
pair<const char*, double> charDoub2= make_pair("str", 3.14);
auto charDoub3= make_pair("str", 3.14);

cout << charDoub.first << ", " << charDoub.second;    // str, 3.14
charDoub.first="Str";
get<1>(charDoub)= 4.14;
cout << charDoub.first << ", " << charDoub.second;    // str, 4.14

Tuples

You can create tuples of arbitrary length and types with std::tuple. The class template needs the header <tuple>. std::tuple is a generalization of std::pair. You can convert between tuples with two elements and pairs. The tuple has, like his small brother std::pair, a default, a copy and a move constructor. You can swap tuples with the function std::swap.

The i-th element of a tuple t can be referenced by the function template std::get: std::get<i-1>(t). By std::get<type>(t) you can directly refer to the element of the type type.

Tuples support the comparison operators ==, !=, <, >, <= and >=. If you compare two tuples, the elements of the tuples will be compared lexicographically. The comparison starts at the index 0.

std::make_tuple

The helper function std::make_tuple is quite convenient for the creation of tuples. You don’t have to provide the types. The compiler automatically deduces them.

// tuple.cpp 
...
#include <tuple>
...
using std::get;

std::tuple<std::string, int, float> tup1("first", 3, 4.17f);
auto tup2= std::make_tuple("second", 4, 1.1);

std::cout << get<0>(tup1) << ", " << get<1>(tup1) << ", "
          << get<2>(tup1) << std::endl; // first, 3, 4.17
std::cout << get<0>(tup2) << ", " << get<1>(tup2) << ", "
          << get<2>(tup2) << std::endl; // second, 4, 1.1
std::cout << (tup1 < tup2) << std::endl; // true

get<0>(tup2)= "Second";

std::cout << get<0>(tup2) << "," << get<1>(tup2) << ","
          << get<2>(tup2) << std::endl;  // Second, 4, 1.1
std::cout << (tup1 < tup2) << std::endl; // false

auto pair= std::make_pair(1, true);
std::tuple<int, bool> tup= pair;

std::tie and std::ignore

std::tie enables you to create tuples, which elements reference variables. With std::ignore you can explicitly ignore elements of the tuple.

// tupleTie.cpp 
...
#include <tuple>
...
using namespace std;

int first= 1;
int second= 2;
int third= 3;
int fourth= 4;
cout << first << " " << second << " "
     << third << " " << fourth << endl;          // 1 2 3 4

auto tup= tie(first, second, third, fourth)      // bind the tuple
        = std::make_tuple(101, 102, 103, 104);   // create the tuple 
                                                 // and assign it
cout << get<0>(tup) << " " << get<1>(tup) << " " << get<2>(tup)
     << " " << get<3>(tup) << endl;              // 101 102 103 104
cout << first << " " << second << " " << third << " "
     << fourth << endl;                          // 101 102 103 104

first= 201;
get<1>(tup)= 202;
cout << get<0>(tup) << " " << get<1>(tup) << " " << get<2>(tup)
     << " " << get<3>(tup) << endl;              // 201 202 103 104
cout << first << " " << second << " " << third << " "
     << fourth << endl;                          // 201 202 103 104

int a, b;
tie(std::ignore, a, std::ignore, b)= tup;
cout << a << " " << b << endl;                   // 202 104

Reference Wrappers

A reference wrapper is a copy-constructible and copy-assignable wrapper for a object of type&, which is defined in the header <functional>. So you have an object, that behaves like a reference, but can be copied. In opposite to classic references, std::reference_wrapper objects support two additional use cases:

• You can use them in containers of the Standard Template Library. std::vector<std::reference_wrapper<int>> myIntRefVector
• You can copy instances of classes, which have std::reference_wrapper objects. That is in general not possible with references.

To access the reference of a std::reference_wrapper<int> myInt(1), the get method can be used: myInt.get(). You can use a reference wrapper to encapsulate and invoke a callable.

// referenceWrapperCallable.cpp 
...
#include <functional>
...
void foo(){ 
  std::cout << "Invoked" << std::endl; 
}

typedef void callableUnit();
std::reference_wrapper<callableUnit> refWrap(foo);

refWrap();                           // Invoked

std::ref and std::cref

With the helper functions std::ref and std::cref you can easily create reference wrappers to variables. std::ref will create a non-constant reference wrapper, std::cref a constant one:

// referenceWrapperRefCref.cpp 
...
#include <functional>
...
void invokeMe(const std::string& s){
  std::cout << s << ": const " << std::endl;
}

template <typename T>
  void doubleMe(T t){ 
  t*= 2; 
}

std::string s{"string"};

invokeMe(std::cref(s));        // string

int i= 1;
std::cout << i << std::endl;   // 1

doubleMe(i);
std::cout << i << std::endl;   // 1S

doubleMe(std::ref(i));
std::cout << i << std::endl;   // 2

So it’s possible to invoke the function invokeMe, which gets a constant reference to a std::string, with a non-constant std::string s, which is wrapped in a std::cref(s). If I wrap the variable i in the helper function std::ref, the function template doubleMe will be invoked with a reference. So the variable i will be doubled.

Smart Pointers

Smart pointers are one of the most important additions to C++ because they empower you to implement explicit memory management in C++. Beside the deprecated std::auto_ptr, C++ offers three different smart pointers. They are defined in the header <memory>.

Firstly there is the std::unique_ptr, which models the concept of exclusive ownership. Secondly, there is the std::shared_ptr, who models the concept of shared ownership. Lastly, there is the std::weak_ptr. std::weak_ptr is not so smart, because it has only a thin interface. Its job is it to break cycles of std::shared_ptr. It models the concept of temporary ownership.

The smart pointers manage their resource according to the RAII idiom. So the resource is automatically released if the smart pointer goes out of scope.

std::unique_ptr

std::unique_ptr exclusively takes care of its resource. It automatically releases the resource if it goes out of scope. If there is no copy semantic required, it can be used in containers and algorithms of the Standard Template Library. std::unique_ptr is as cheap and fast as a raw pointer if you use no special deleter.

These are the methods of std::unique_ptr.

In the following code sample you can see the application of these methods:

// uniquePtr.cpp 
...
#include <utility>
...
using namepace std;

struct MyInt{
  MyInt(int i):i_(i){}
  ~MyInt(){
    cout << "Good bye from " << i_ << endl;
  }
  int i_;
};

unique_ptr<MyInt> uniquePtr1{new MyInt(1998)};
cout << uniquePtr1.get() << endl;               // 0x15b5010

unique_ptr<MyInt> uniquePtr2{move(uniquePtr1)};
cout << uniquePtr1.get() << endl;               // 0
cout << uniquePtr2.get() << endl;               // 0x15b5010
{
  unique_ptr<MyInt> localPtr{new MyInt(2003)};
}                                               // Good bye from 2003
uniquePtr2.reset(new MyInt(2011));              // Good bye from 1998
MyInt* myInt= uniquePtr2.release();
delete myInt;                                   // Good by from 2011

unique_ptr<MyInt> uniquePtr3{new MyInt(2017)};
unique_ptr<MyInt> uniquePtr4{new MyInt(2022)};
cout << uniquePtr3.get() << endl;               // 0x15b5030
cout << uniquePtr4.get() << endl;               // 0x15b5010

swap(uniquePtr3, uniquePtr4);
cout << uniquePtr3.get() << endl;               // 0x15b5010
cout << uniquePtr4.get() << endl;               // 0x15b5030

std::unique_ptr has a specialisation for arrays:

// uniquePtrArray.cpp 
...
#include <memory>
...
using namespace std;

class MyStruct{
public:
  MyStruct():val(count){
    cout << (void*)this << " Hello: " << val << endl;
    MyStruct::count++;
  }
  ~MyStruct(){
    cout << (void*)this << " Good Bye: " << val << endl;
    MyStruct::count--;
  }
private:
  int val;
  static int count;
};

int MyStruct::count= 0;
...
{
  // generates a myUniqueArray with thre `MyStructs` 
  unique_ptr<MyStruct[]> myUniqueArray{new MyStruct[3]};
}
// 0x1200018 Hello: 0
// 0x120001c Hello: 1
// 0x1200020 Hello: 2
// 0x1200020 GoodBye: 2
// 0x120001c GoodBye: 1
// 0x1200018 GoodBye: 0

Special Deleters

std::unique_ptr can be parametrized with special deleters: std::unique_ptr<int, MyIntDeleter> up(new int(2011), myIntDeleter()). std::unique_ptr uses by default the deleter of the resource.

std::make_unique

The helper function std::make_unique was unlike its sibling std::make_shared forgotten in the C++11 standard. So std::make_unique was added with the C++14 standard. std::make_unique enables it to create a std::unique_ptr in a single step: std::unique_ptr<int> up= std::make_unique<int>(2014).

std::shared_ptr

std::shared_ptr shares the ownership of the resource. They have two handles. One for the resource and one for the reference counter. By copying a std::shared_ptr, the reference count isincreased by one. It is decreased by one if the std::shared_ptr goes out of scope. If the reference counter becomes the value 0 and therefore there is no std::shared_ptr referencing the resource, the C++ runtime automatically releases the resource. The release of the resource takes place at exactly the time at which the last std::shared_ptr goes out of scope. The C++ runtime guarantees that the call of the reference counter is an atomic operation. Because of this management, std::shared_ptr uses more time and memory than a raw pointer or std::unique_ptr.

In the following table are the methods of std::shared_ptr.

std::make_shared

The helper function std::make_shared creates the resource and returns it in a std::shared_ptr. You should use std::make_shared instead of the direct creation of a std::shared_ptr, because std::make_shared is a lot faster.

The following code sample shows a typical use case of a std::shared_ptr.

// sharedPtr.cpp 
...
#include <memory>
...
class MyInt{
public:
  MyInt(int v):val(v){
    std::cout << "Hello: " << val << std::endl;
  }
  ~MyInt(){
    std::cout << "Good Bye: " << val << std::endl;
  }
private:
  int val;
};

auto sharPtr= std::make_shared<MyInt>(1998);        // Hello: 1998
std::cout << sharPtr.use_count() << std::endl;      // 1

{
  std::shared_ptr<MyInt> locSharPtr(sharPtr);
  std::cout << locSharPtr.use_count() << std::endl; // 2
}
std::cout << sharPtr.use_count() << std::endl;      // 1

std::shared_ptr<MyInt> globSharPtr= sharPtr;
std::cout << sharPtr.use_count() << std::endl;      // 2

globSharPtr.reset();
std::cout << sharPtr.use_count() << std::endl;     // 1
sharPtr= std::shared_ptr<MyInt>(new MyInt(2011));  // Hello:2011
                                                   // Good Bye: 1998
...
// Good Bye: 2011

The callable is in this example a function object. Therefore you can easily count how many instances of a class were created. The result is in the static variable count.

std::shared_ptr from this

You can create with the class std::enable_shared_from_this objects which return a std::shared_ptr on itself. For that you have to derive the class public from std::enable_shared_from_this. So the class support the method shared_from_this to return std::shared_ptr to this:

// enableShared.cpp
...
#include <memory>
...
class ShareMe: public std::enable_shared_from_this<ShareMe>{
  std::shared_ptr<ShareMe> getShared(){
    return shared_from_this();
  }
};

std::shared_ptr<ShareMe> shareMe(new ShareMe);
std::shared_ptr<ShareMe> shareMe1= shareMe->getShared();

std::cout << (void*)shareMe.get() << std::endl;   // 0x152d010
std::cout << (void*)shareMe1.get() << std::endl;  // 0x152d010
std::cout << shareMe.use_count() << std::endl;    // 2

You can see in the code sample that the get methods reference the same object.

std::weak_ptr

To be honest, std::weak_ptr is not a smart pointer. std::weak_ptr supports no transparent access to the resource because it only borrows the resource from a std::shared_ptr. std::weak_ptr does not change the reference counter:

// weakPtr.cpp
...
#include <memory>
...
auto sharedPtr= std::make_shared<int>(2011);
std::weak_ptr<int> weakPtr(sharedPtr);

std::cout << weakPtr.use_count() << std::endl;       // 1
std::cout << sharedPtr.use_count() << std::endl;     // 1

std::cout << weakPtr.expired() << std::endl;         // false
if( std::shared_ptr<int> sharedPtr1= weakPtr.lock() ) {
  std::cout << *sharedPtr << std::endl; // 2011
}
else{
  std::cout << "Don't get it!" << std::endl;
}

weakPtr.reset();

if( std::shared_ptr<int> sharedPtr1= weakPtr.lock() ) {
  std::cout << *sharedPtr << std::endl;
}
else{
  std::cout << "Don't get it!" << std::endl;         // Don't get it!
}

The table provides an overview of the methods of std::weak_ptr.

There is one reason for the existence of std::weak_ptr. It breaks the cycle of std::shared_ptr.

Cyclic References

You get cyclic references of std::shared_ptr if they refer to each other. So, the resource counter never becomes 0 and the resource is not automatically released. You can break this cycle if you embed a std::weak_ptr in the cycle. std::weak_ptr does not modify the reference counter.

The result of the code sample is that the daughter automatically released, but not the son nor the mother. The mother refers to her son via a std::shared_ptr, her daughter via a std::weak_ptr. Maybe it helps to see the structure of the code in an image.

Finally the source code.

// cyclicReference.cpp 
...
#include <memory>
...
using namespace std;

struct Son, Daughter;

struct Mother{
  ~Mother(){cout << "Mother gone" << endl;}
   void setSon(const shared_ptr<Son> s ){mySon= s;}
   void setDaughter(const shared_ptr<Daughter> d){myDaughter= d;}
   shared_ptr<const Son> mySon;
   weak_ptr<const Daughter> myDaughter;
};

struct Son{
Son(shared_ptr<Mother> m):myMother(m){}
  ~Son(){cout << "Son gone" << endl;}
  shared_ptr<const Mother> myMother;
};

struct Daughter{
Daughter(shared_ptr<Mother> m):myMother(m){}
  ~Daughter(){cout << "Daughter gone" << endl;}
  shared_ptr<const Mother> myMother;
};

{
  shared_ptr<Mother> mother= shared_ptr<Mother>(new Mother);
  shared_ptr<Son> son= shared_ptr<Son>(new Son(mother) );
  shared_ptr<Daughter> daugh= shared_ptr<Daughter>(new Daughter(mother));
  mother->setSon(son);
  mother->setDaughter(daugh);
}
                               // Daughter gone

Type Traits

The type traits library enables you, to check, to compare and to modify types at compile time. So, there is no overhead on the runtime of your program. There are two reasons for using the type traits library: Optimization and Correctness. Optimization, because the introspection capabilities of the type traits library make it possible to choose the faster code automatically. Correctness, because you can specify requirements for your code, which is checked at compile time.

Check Type Information

With the type traits library, you can check primary and composite type categories. The attribute value gives you the result.

Primary Type Categories

There are 14 different type categories. They are complete and don’t overlap. So each type is only a member of one type category. If you check a type category for your type, the request is independent of the const or volatile qualifiers.

template <class T> struct is_void;
template <class T> struct is_integral; 
template <class T> struct is_floating_point; 
template <class T> struct is_array;
template <class T> struct is_pointer;
template <class T> struct is_null_pointer;
template <class T> struct is_member_object_pointer;
template <class T> struct is_member_function_pointer;
template <class T> struct is_enum;
template <class T> struct is_union;
template <class T> struct is_class;
template <class T> struct is_function;
template <class T> struct is_lvalue_reference;
template <class T> struct is_rvalue_reference;

The following code samples show all primary type categories.

// typeCategories.cpp 
...
#include <type_traits>
using std::cout;

cout << std::is_void<void>::value;             // true
cout << std::is_integral<short>::value;        // true
cout << std::is_floating_point<double>::value; // true
cout << std::is_array<int [] >::value;         // true
cout << std::is_pointer<int*>::value;          // true
cout << std::is_reference<int&>::value;        // true

struct A{
  int a;
  int f(int){ return 2011; }
};
cout << std::is_member_object_pointer<int A::*>::value;          // true
cout << std::is_member_function_pointer<int (A::*)(int)>::value; // true

enum E{
  e= 1,
};
cout << std::is_enum<E>::value;                  // true

union U{
  int u;
};
cout << std::is_union<U>::value;                 // true

cout << std::is_class<std::string>::value;       // true
cout << std::is_function<int * (double)>::value; // true
cout << std::is_lvalue_reference<int&>::value;   // true
cout << std::is_rvalue_reference<int&&>::value;  // true

Composite Type Categories

Based on the 14 primary type categories, there are seven composite type categories.

Type Properties

In addition to the primary and composite type categories, there are many type properties.

template <class T> struct is_const;
template <class T> struct is_volatile;
template <class T> struct is_trivial;
template <class T> struct is_trivially_copyable;
template <class T> struct is_standard_layout;
template <class T> struct is_pod
template <class T> struct has_unique_object_represenation;
template <class T> struct is_empty;
template <class T> struct is_polymorphic;
template <class T> struct is_abstract;
template <class T> struct is_final;
template <class T> struct is_aggregate;

template <class T> struct is_signed;
template <class T> struct is_unsigned;

template <class T, class... Args> struct is_constructible;
template <class T> struct is_default_constructible;
template <class T> struct is_copy_constructible;
template <class T> struct is_move_constructible;

template <class T, class U> struct is_assignable;
template <class T> struct is_copy_assignable;
template <class T> struct is_move_assignable;
template <class T> struct is_destructible;
template <class T, class... Args> struct is_trivially_constructible;
template <class T> struct is_trivially_default_constructible;
template <class T> struct is_trivially_copy_constructible;
template <class T> struct is_trivially_move_constructible;
template <class T, class U> struct is_trivially_assignable;
template <class T> struct is_trivially_copy_assignable;
template <class T> struct is_trivially_move_assignable;

template <class T> struct is_trivially_destructible;

template <class T, class... Args> struct is_nothrow_constructible;
template <class T> struct is_nothrow_default_constructible;
template <class T> struct is_nothrow_copy_constructible;
template <class T> struct is_nothrow_move_constructible;

template <class T, class U> struct is_nothrow_assignable;
template <class T> struct is_nothrow_copy_assignable;
template <class T> struct is_nothrow_move_assignable;

template <class T> struct is_nothrow_destructible;
template <class T> struct has_virtual_destructor;

template <class T> struct is_swappable_with;
template <class T> struct is_swappable;
template <class T> struct is_nothrow_swappable_with;
template <class T> struct is_nothrow_swappable;

Type Comparisons

The library supports three kinds of type comparisons.

Type modifications

The type traits library enables you to modify types during compile time. You can modify the constness of a type:

// typeTraitsModifications.cpp 
...
#include <type_traits>
...
using namespace std;

cout << is_const<int>::value;                     // false
cout << is_const<const int>::value;               // true
cout << is_const<add_const<int>::type>::value;    // true

typedef add_const<int>::type myConstInt;
cout << is_const<myConstInt>::value;              //true

typedef const int myConstInt2;
cout << is_same<myConstInt, myConstInt2>::value;  // true

cout << is_same<int, remove_const<add_const<int>::type>::type>::value;    // true
cout << is_same<const int, add_const<add_const<int>::type>::type>::value; // true

The function std::add_const adds the constness to a type, while std::remove_const removes it.

There are a lot more functions available in the type traits library. You can modify the const-volatile properties of a type.

template <class T> struct remove_const;
template <class T> struct remove_volatile;
template <class T> struct remove_cv;

template <class T> struct add_const;
template <class T> struct add_volatile;
template <class T> struct add_cv;

You can change at compile time the sign,

template <class T> struct make_signed;
template <class T> struct make_unsigned;

or the reference or pointer properties of a type.

template <class T> struct remove_reference;
template <class T> struct add_lvalue_reference;
template <class T> struct add_rvalue_reference;

template <class T> struct remove_pointer;
template <class T> struct add_pointer;

The three following functions are especially valuable for the writing of generic libraries.

template <class B> struct enable_if;
template <class B, class T, class F> struct conditional;
template <class... T> common_type;

You can conditionally hide with std::enable_if a function overload or template specialization from overload resolution. std::conditional provides you with the ternary operator at compile time and std::common_type gives you the type, to which all type parameter can be implicitly converted to. std::common_type is a variadic template, therefore the number of type parameters can be arbitrary.

Const evaluated Context

The call std::is_constant_evaluated allows you to detect if a function call occurs at compile time.

// constantEvaluated.cpp
#include <type_traits>
...
 
constexpr double power(double b, int x) {
    if (std::is_constant_evaluated() && !(b == 0.0 && x < 0)) {
        
        if (x == 0)
            return 1.0;
        double r = 1.0, p = x > 0 ? b : 1.0 / b;
        auto u = unsigned(x > 0 ? x : -x);
        while (u != 0) {
            if (u & 1) r *= p;
            u /= 2;
            p *= p;
        }
        return r;
    } 
    else {
        return std::pow(b, double(x));
    }
}
 
constexpr double kilo1 = power(10.0, 3);      // execution at compile time
    
int n = 3;
double kilo2 = power(10.0, n);                // execution at runtime
std::cout << "kilo2: " << kilo2 << std::endl;

Time Library

The time library consists of the three main components, time point, time duration, and clock. Additionally, the library provides the time of day functionality, calendar support, time zone support, and support for in- and output.

Time point

Time point is defined by a starting point, the so-called epoch, and an additional time duration.

Time duration

Time duration is the difference between two time-points. It is given by the number of ticks.

Clock

A clock consists of a starting point (epoch) and a tick so that the current time point can be calculated.

Time of day

The duration since midnight split into hours:minutes:seconds.

Calendar

Calendar stands for various calendar days such as year, a month, a weekday, or the n-th day of a week.

Time zone

Represents time specific to a geographic area.

Time Point

A duration consists of a span of time, defined as some number of ticks of some time unit. A time point consists of a clock and a time duration. This time duration can be positive or negative.

template <class Clock, class Duration= typename Clock::duration>
class time_point;

The epoch is not defined for the clocks std::chrono::steady_clock, std::chrono::high_resolution_clock and std::chrono::system. But on the popular platform the epoch of std::chrono::system is usually defined as 1.1.1970. You can calculate the time since 1.1.1970 in the resolutions nanoseconds, seconds and minutes.

// epoch.cpp 
...
#include <chrono>
...
auto timeNow= std::chrono::system_clock::now();
auto duration= timeNow.time_since_epoch();
std::cout << duration.count() << "ns"      // 1413019260846652ns

typedef std::chrono::duration<double> MySecondTick;
MySecondTick mySecond(duration);
std::cout << mySecond.count() << "s";      // 1413019260.846652s

const int minute= 60;
typedef std::chrono::duration<double, <minute>> MyMinuteTick;
MyMinuteTick myMinute(duration);
std::cout << myMinute.count() << "m";      // 23550324.920572m

Thanks to the function std::chrono::clock_cast you can cast time points between various clocks.

Time Duration

Time duration is the difference between the two time-points. Time duration is measured in the number of ticks.

template <class Rep, class Period = ratio<1>> class duration;

If Rep is a floating point number, the time duration supports fractions of ticks. The most important time durations are predefined in the chrono library:

typedef duration<signed int, nano> nanoseconds;
typedef duration<signed int, micro> microseconds;
typedef duration<signed int, milli> milliseconds;
typedef duration<signed int> seconds;
typedef duration<signed int, ratio< 60>> minutes;
typedef duration<signed int, ratio<3600>> hours;

How long can a time duration be? The C++ standard guarantees that the predefined time durations can store +/- 292 years. You can easily define your time duration like a German school hour: typedef std::chrono::duration<double, std::ratio<2700>> MyLessonTick. Time durations in natural numbers have to be explicitly converted to time durations in floating pointer numbers. The value will be truncated:

// duration.cpp 
...
#include <chrono>
#include <ratio>

using std::chrono;

typedef duration<long long, std::ratio<1>> MySecondTick;
MySecondTick aSecond(1);

milliseconds milli(aSecond);
std::cout << milli.count() << " milli";        // 1000 milli

seconds seconds(aSecond);
std::cout << seconds.count() << " sec";         // 1 sec

minutes minutes(duration_cast<minutes>(aSecond));
std::cout << minutes.count() << " min";         // 0 min

typedef duration<double, std::ratio<2700>> MyLessonTick;
MyLessonTick myLesson(aSecond);
std::cout << myLesson.count() << " less";       // 0.00037037 less

C++14 has built-in literals for the most used time durations.

Clock

The clock consists of a starting point and a tick. You can get the current time with the method now.

std::chrono::system_clock

System time, which you can synchronise with the external clock.

std::chrono::steady_clock

Clock, which can not be adjusted.

std::chrono::high_resolution_clock

System time with the greatest accuracy.

std::chrono::system_clock will refer typically to the 1.1.1970. You can not adjust std::steady_clock forward or backward in opposite to two other clocks. The methods to_time_t and from_time_t can be used to convert between std::chrono::system_clock and std::time_t objects.

Time of Day

std::chrono::time_of_day splits the duration since midnight into hours:minutes:seconds. The functions std::chrono::is_am and std::chrono::is_pm checks if the time is before midday (ante meridiem) or after midday (post meridiem).

A std::chrono::time_of_day object tOfDay supports various member functions.

Calendar

Calendar stands for various calender dates such as year, a month, a weekday, or the n-th day of a week.

// currentTime.cpp 
...
#include <chrono>
using std::chrono;
...
auto now = system_clock::now();
std::cout << "The current time is " << now << " UTC\n";      

auto currentYear = year_month_day(floor<days>(now)).year();
std::cout << "The current year is " << currentYear << '\n';    

auto h = floor<hours>(now) - sys_days(January/1/currentYear);
std::cout << "It has been " << h << " since New Years!\n"; 

std::cout << std::endl;

auto birthOfChrist = year_month_weekday(sys_days(January/01/0000));
std::cout << "Weekday: " << birthOfChrist.weekday() << '\n'; 

The output of the program shows information referring the current time.

The following table gives an overview on the calender types.

Time Zone

Time zones represent time specific to a geograhic area. The following program snippe displays the local time in various time zones.

// timezone.cpp
...
#include <chrono>
using std::chrono;
..
auto time = floor<milliseconds>(system_clock::now());
auto localTime = zoned_time<milliseconds>(current_zone(), time);
auto berlinTime = zoned_time<milliseconds>("Europe/Berlin", time);
auto newYorkTime = std::chorno::zoned_time<milliseconds>("America/New_York", time);
auto tokyoTime = zoned_time<milliseconds>("Asia/Tokyo", time);
    

std::cout << time << std::endl; 
std::cout << localTime << std::endl; 
std::cout << berlinTime << std::endl; 
std::cout << newYorkTime << std::endl; 
std::cout << tokyoTime << std::endl; 

The time zone functionality supports the access of the IANA time zone database, enables the opeartion with various time zones, and provides information about leap seconds.

The following table gives an overview of the time zone functionaliy. For more detailed information, refer to cpprefere.com.

Chrono I/O

The function std::chrono::parse parses a chrono object from a stream.

std::istringstream inputStream{"1999-10-31 01:30:00 -08:00 US/Pacific"};
    
std::chrono::local_seconds timePoint;
std::string timeZone;
inputStream >> std::chrono::parse("%F %T %Ez %Z", timePoint, timeZone);

The parse functionality provides various format specifizer to deal with time of day and calendar dates such as year, month, week, and day. cppreference.com provides detailed information to the format spezifieres.

std::any, std::optional, and std::variant

The new C++17 data types std::any, std::optional, and std::variant are all based on the Boost libraries

std::any

std::any is a type-safe container for single values of any type which is copy-constructible. There are a few ways to create a std::any container any. You can use the various constructors or the factory function std::make_any. By using any.emplace, you directly construct one value into any. any.reset lets you destroy the contained object. If you want to know whether the container any has a value, use the method any.has_value. You can even get the typeid of the container object via any.type. Thanks to the generic function std::any_cast you have access to the contained object. If you specify the wrong type, you will get a std::bad_any_cast exception.

Here is a code snippet showing the basic usage of std::any.

// any.cpp
...
#include <any>

struct MyClass{};

...

std::vector<std::any> anyVec{true, 2017, std::string("test"), 3.14,  MyClass()};
std::cout << std::any_cast<bool>(anyVec[0]);                          // true
int myInt= std::any_cast<int>(anyVec[1]);                                        
std::cout << myInt << std::endl;                                      // 2017
    
std::cout << anyVec[0].type().name();                                 // b 
std::cout << anyVec[1].type().name();                                 // i

The program snippet defines a std::vector<std::any>. To get one of its elements, you have to use std::any_cast. As mentioned, if you use the wrong type, you will get a std::bad_any_cast exception.

std::any can have objects of arbitrary types; std::optional may or may not have a value.

std::optional

std::optional is quite comfortable for calculations such as database queries that may have a result.

The variuous constructors and the convenience function std::make_optional let you define an optional object opt with or without a value. opt.emplace will construct the contained value in-place and opt.reset will destroy the container value. You can explicitly ask a std::optional container if it has a value or you can check it in a logical expression. opt.value returns the value and opt.value_or returns the value or a default value. If opt has no contained value, the call opt.value will throw a std::bad_optional_access exception.

Here is a short example of using std::optional.

// optional.cpp
...
#include <optional>

std::optional<int> getFirst(const std::vector<int>& vec){
  if (!vec.empty()) return std::optional<int>(vec[0]);
  else return std::optional<int>();
}

...
    
std::vector<int> myVec{1, 2, 3};
std::vector<int> myEmptyVec;
    
auto myInt= getFirst(myVec);
    
if (myInt){
  std::cout << *myInt << std::endl;                       // 1
  std::cout << myInt.value() << std::endl;                // 1
  std::cout << myInt.value_or(2017) << std::endl;         // 1
}
    
auto myEmptyInt= getFirst(myEmptyVec);
    
if (!myEmptyInt){
  std::cout << myEmptyInt.value_or(2017) << std::endl;   // 2017
}  

I use std::optional in the function getFirst. getFirst returns the first element if it exists. If not, you will get a std::optional<int> object. The main function has two vectors. Both invoke getFirst and return a std::optional object. In the case of myInt the object has a value; in the case of myEmptyInt, the object has no value. The program displays the value of myInt and myEmptyInt. myInt.value_or(2017) returns the value, but myEmptyInt.value_or(2017) returns the default value.

std::variant, explained in the next section, can have more than one value.

std::variant

std::variant is a type-safe union. An instance of std::variant has a value from one of its types. The type must not be a reference, array or void. A std::variant can have a type more than once. A default-initialised std::variant is initialised with its first type; therefore, its first type must have a default constructor. By using var.index you get the zero-based index of the alternative held by the std::variant var. var.valueless_by_exception returns false if the variant holds a value. By using var.emplace you can create a new value in-place. There are a few global functions used to access a std:variant. The function template var.holds_alternative lets you check if the std::variant holds a specified alternative. You can use std::get with an index and with a type as argument. By using an index, you will get the value. If you invoke std::get with a type, you only will get the value if it is unique. If you use an invalid index or a non-unique type, you will get a std::bad_variant_access exception. In contrast to std::get which eventually returns an exception, std::get_if returns a null pointer in the case of an error.

The following code snippet shows you the usage of a std::variant.

// variant.cpp 
...
#include <variant>

...

std::variant<int, float> v, w;
v = 12;                             // v contains int
int i = std::get<int>(v);
w = std::get<int>(v);
w = std::get<0>(v);                 // same effect as the previous line
w = v;                              // same effect as the previous line
 
//  std::get<double>(v);            // error: no double in [int, float]
//  std::get<3>(v);                 // error: valid index values are 0 and 1
 
try{
  std::get<float>(w);               // w contains int, not float: will throw
}
catch (std::bad_variant_access&) {}
 
std::variant<std::string> v("abc"); // converting constructor must be unambiguous
v = "def";                          // converting assignment must be unambiguous

v and w are two variants. Both can have an int and a float value. Their default value is 0. v becomes 12 and the following call std::get<int>(v) returns the value. The next three lines show three possibilities to assign the variant v to w, but you have to keep a few rules in mind. You can ask for the value of a variant by type std::get<double>(v) or by index: std::get<3>(v). The type must be unique and the index valid. The variant w holds an int value; therefore, I get a std::bad_variant_access exception if I ask for a float type. If the constructor call or assignment call is unambiguous, a conversion can take place. This is the reason that it’s possible to construct a std::variant<std::string> from a C-string or assign a new C-string to the variant.

std::variant has an interesting non-member function std::visit that allows you the execute a callable on a list of variants. A callable is something which you can invoke. Typically this can be a function, a function object, or lambda expression. For simplicity reasons, I use a lambda function in this example.

// visit.cpp 
...
#include <variant>

...
  
std::vector<std::variant<char, long, float, int, double, long long>>      
           vecVariant = {5, '2', 5.4, 100ll, 2011l, 3.5f, 2017};

for (auto& v: vecVariant){        
  std::visit([](auto&& arg){std::cout << arg << " ";}, v);    
                                   // 5 2 5.4 100 2011 3.5 2017                
}
  
// display each type
for (auto& v: vecVariant){
  std::visit([](auto&& arg){std::cout << typeid(arg).name() << " ";}, v);  
                                  // int char double __int64 long float int
}
  
// get the sum
std::common_type<char, long, float, int, double, long long>::type res{};  
 
std::cout << typeid(res).name() << std::endl;        // double
  
for (auto& v: vecVariant){
  std::visit([&res](auto&& arg){res+= arg;}, v);     
}
std::cout << "res: " << res << std::endl;            // 4191.9
  
// double each value
for (auto& v: vecVariant){
  std::visit([&res](auto&& arg){arg *= 2;}, v);                           
  std::visit([](auto&& arg){std::cout << arg << " ";}, v);   
                                 // 10 d 10.8 200 4022 7 4034
}

Each variant in this example can hold a char, long, float, int, double, or long long. The first visitor [](auto&& arg){std::cout << arg << " ";} will output the various variants. The second visitor std::cout << typeid(arg).name() << " ";} will display its types.

Now I want to sum up the elements of the variants. First I need the right result type at compile time. std::common_type from the type traits library will provide it. std::common_type gives the type to which all types char, long, float, int, double, and long long can implicitly be converted to. The final {} in res{} causes it to be initialised to 0.0. res is of type double. The visitor [&res](auto&& arg){arg *= 2;} calculates the sum and the following line displays it.

3. Interface of All Containers

Although the sequence and associative containers of the Standard Template library are two quite different classes of containers, they have a lot in common. For example, the operations, to create or delete a container, to determine its size, to access its elements, to assign or swap are all independent of the type of elements of a container. It is common for the containers that you can define them with an arbitrary size, and each container has an allocator. That’s the reason the size of a container can be adjusted at runtime. The allocator works most of the time in the background. This can be seen for a std::vector. The call std::vector<int> results in a call std::vector<int, std::allocator<int>>. Because of the std::allocator, you can adjust except for std::array the size of all containers dynamically. However, they have yet more in common. You can access the elements of a container quite easily with an iterator.

Having so much in common, the containers differ in the details. The chapters Sequence Container and Associative Container provide the details.

With the sequence containers std::array, std::vector, std::deque, std::list, and std::forward_list C++ has an expert on each domain.

The same holds true for the associative containers, which can be classified in the order and unordered ones.

Create and delete

You can construct each container by a multitude of constructors. To delete all elements of a container cont, you can use cont.clear(). It makes no difference if you create a container, if you delete them or if you add or remove elements. Each time the container takes care of the memory management.

The table shows you the constructors and destructors of a container. A std:vector stands for the rest of them.

Because std::array is generated at compile time, it is a special container. std::array has no move constructor and can neither be created with a range nor with an initialiser list. However, you can initialize a std::array with an aggregate initialisation. Also, std::array has no method for removing its elements.

Now I can use the different constructors on the different containers.

// containerConstructor.cpp
...
#include <map>
#include <unordered_map>
#include <vector>
...
using namespace std;

vector<int> vec= {1, 2, 3, 4, 5, 6, 7, 8, 9};
map<string, int> m= {{"bart", 12345}, {"jenne", 34929}, {"huber", 840284} };
unordered_map<string, int> um{m.begin(), m.end()};

for (auto v: vec) cout << v << " "; // 1 2 3 4 5 6 7 8 9
for (auto p: m) cout << p.first << "," << p.second << " ";
                                    // bart,12345 huber,840284 jenne,34929
for (auto p: um) cout << p.first << "," << p.second << " ";
                                    // bart,12345 jenne,34929 huber,840284

vector<int> vec2= vec;
cout << vec.size() << endl; // 9
cout << vec2.size() << endl; // 9

vector<int> vec3= move(vec);
cout << vec.size() << endl; // 0
cout << vec3.size() << endl; // 9

vec3.clear();
cout << vec3.size() << endl; // 0

Size

For a container cont, you can check with cont.empty() if the container is empty. cont.size() returns the current number of elements, and cont.max_size() returns the maximum number of elements cont can have. The maximum number of elements is implementation-defined.

// containerSize.cpp 
...
#include <map>
#include <set>
#include <vector>
...
using namespace std;

vector<int> intVec{1, 2, 3, 4, 5, 6, 7, 8, 9};
map<string, int> str2Int = {{"bart", 12345}, 
                            {"jenne", 34929}, {"huber", 840284}};
set<double> douSet{3.14, 2.5};

cout << intVec.empty() << endl;  // false
cout << str2Int.empty() << endl; // false
cout << douSet.empty() << endl;  // false

cout << intVec.size() << endl;  // 9
cout << str2Int.size() << endl; // 3
cout << douSet.size() << endl;  // 2

cout << intVec.max_size() << endl;  // 4611686018427387903
cout << str2Int.max_size() << endl; // 384307168202282325
cout << douSet.max_size() << endl;  // 461168601842738790

Access

To access the elements of a container, you can use an iterator. If you use a begin and end iterator, you have a range, which you can further process. For a container cont, you get with cont.begin() the begin iterator and with cont.end() the end iterator, which defines a half-open range. It is half-open because the begin iterator belongs to the range, the end iterator refers to a position past the range. With the iterator pair cont.begin() and cont.end() you can modify the elements.

Now I can modify the container.

// containerAccess.cpp
...
#include <vector>
...
struct MyInt{
  MyInt(int i): myInt(i){};
  int myInt;
};

std::vector<MyInt> myIntVec;
myIntVec.push_back(MyInt(5));
myIntVec.emplace_back(1);
std::cout << myIntVec.size() << std::endl;         // 2

std::vector<int> intVec;
intVec.assign({1, 2, 3});
for (auto v: intVec) std::cout << v << " ";        // 1 2 3

intVec.insert(intVec.begin(), 0);
for (auto v: intVec) std::cout << v << " ";        // 0 1 2 3

intVec.insert(intVec.begin()+4, 4);
for (auto v: intVec) std::cout << v << " ";        // 0 1 2 3 4

intVec.insert(intVec.end(), {5, 6, 7, 8, 9, 10, 11}); 

for (auto v: intVec) std::cout << v << " ";        // 0 1 2 3 4 5 6 7 8 9 10 11

for (auto revIt= intVec.rbegin(); revIt != intVec.rend(); ++revIt) 
     std::cout << *revIt << " ";                   // 11 10 9 8 7 6 5 4 3 2 1 0 

intVec.pop_back();
for (auto v: intVec ) std::cout << v << " ";       // 0 1 2 3 4 5 6 7 8 9 10

Assign and Swap

You can assign new elements to existing containers or swap two containers. For the assignment of a container cont2 to a container cont, there exists the copy assignment cont= cont2 and the move assignment cont= std::move(cont2). A special form of assignment is the one with an initialiser list: cont= {1, 2, 3, 4, 5}. That’s not possible for std::array, but you can instead use the aggregate initialisation. The function swap exists in two forms. You have it as a method cont(swap(cont2)) or as a function template std::swap(cont, cont2).

// containerAssignmentAndSwap.cpp
...
#include <set>
...
std::set<int> set1{0, 1, 2, 3, 4, 5};
std::set<int> set2{6, 7, 8, 9};

for (auto s: set1) std::cout << s << " "; // 0 1 2 3 4 5
for (auto s: set2) std::cout << s << " "; // 6 7 8 9

set1= set2;
for (auto s: set1) std::cout << s << " "; // 6 7 8 9
for (auto s: set2) std::cout << s << " "; // 6 7 8 9

set1= std::move(set2);
for (auto s: set1) std::cout << s << " "; // 6 7 8 9
for (auto s: set2) std::cout << s << " "; //

set2= {60, 70, 80, 90};
for (auto s: set1) std::cout << s << " "; // 6 7 8 9
for (auto s: set2) std::cout << s << " "; // 60 70 80 90

std::swap(set1, set2);
for (auto s: set1) std::cout << s << " "; // 60 70 80 90
for (auto s: set2) std::cout << s << " "; // 6 7 8 9

Compare

Containers support the comparison operators ==, !=, <, >, <=, >=. The comparison of two containers happens on the elements of the containers. If you compare associative containers, their key is compared. Unordered associative containers support only the comparison operator == and !=.

// containerComparison.cpp
...
#include <array>
#include <set>
#include <unordered_map>
#include <vector>
...
using namespace std;

vector<int> vec1{1, 2, 3, 4};
vector<int> vec2{1, 2, 3, 4};
cout << (vec1 == vec2) << endl;       // true

array<int, 4> arr1{1, 2, 3, 4};
array<int, 4> arr2{1, 2, 3, 4};
cout << (arr1 == arr2) << endl;       // true

set<int> set1{1, 2, 3, 4};
set<int> set2{4, 3, 2, 1};
cout << (set1 == set2) << endl;       // true

set<int> set3{1, 2, 3, 4, 5};
cout << (set1 < set3) << endl;        // true

set<int> set4{1, 2, 3, -3};
cout << (set1 > set4) << endl;        // true

unordered_map<int, string> uSet1{{1, "one"}, {2, "two"}};
unordered_map<int, string> uSet2{{1, "one"}, {2, "Two"}};
cout << (uSet1 == uSet2) << endl;     // false